
order_doublelink:     file format elf32-littlearm


Disassembly of section .init:

000103e8 <_init>:
   103e8:	e1a0c00d 	mov	ip, sp
   103ec:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   103f0:	e24cb004 	sub	fp, ip, #4
   103f4:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}

Disassembly of section .plt:

000103f8 <putchar@plt-0x14>:
   103f8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   103fc:	e59fe004 	ldr	lr, [pc, #4]	; 10408 <_init+0x20>
   10400:	e08fe00e 	add	lr, pc, lr
   10404:	e5bef008 	ldr	pc, [lr, #8]!
   10408:	00010718 	.word	0x00010718

0001040c <putchar@plt>:
   1040c:	e28fc600 	add	ip, pc, #0, 12
   10410:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10414:	e5bcf718 	ldr	pc, [ip, #1816]!	; 0x718

00010418 <printf@plt>:
   10418:	e28fc600 	add	ip, pc, #0, 12
   1041c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10420:	e5bcf710 	ldr	pc, [ip, #1808]!	; 0x710

00010424 <puts@plt>:
   10424:	e28fc600 	add	ip, pc, #0, 12
   10428:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1042c:	e5bcf708 	ldr	pc, [ip, #1800]!	; 0x708

00010430 <malloc@plt>:
   10430:	e28fc600 	add	ip, pc, #0, 12
   10434:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10438:	e5bcf700 	ldr	pc, [ip, #1792]!	; 0x700

0001043c <abort@plt>:
   1043c:	e28fc600 	add	ip, pc, #0, 12
   10440:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10444:	e5bcf6f8 	ldr	pc, [ip, #1784]!	; 0x6f8

00010448 <__deregister_frame_info@plt>:
   10448:	e28fc600 	add	ip, pc, #0, 12
   1044c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10450:	e5bcf6f0 	ldr	pc, [ip, #1776]!	; 0x6f0

00010454 <__uClibc_main@plt>:
   10454:	e28fc600 	add	ip, pc, #0, 12
   10458:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1045c:	e5bcf6e8 	ldr	pc, [ip, #1768]!	; 0x6e8

00010460 <scanf@plt>:
   10460:	e28fc600 	add	ip, pc, #0, 12
   10464:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10468:	e5bcf6e0 	ldr	pc, [ip, #1760]!	; 0x6e0

0001046c <__register_frame_info@plt>:
   1046c:	e28fc600 	add	ip, pc, #0, 12
   10470:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10474:	e5bcf6d8 	ldr	pc, [ip, #1752]!	; 0x6d8

00010478 <free@plt>:
   10478:	e28fc600 	add	ip, pc, #0, 12
   1047c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10480:	e5bcf6d0 	ldr	pc, [ip, #1744]!	; 0x6d0

Disassembly of section .text:

00010484 <_start>:
   10484:	e3a0b000 	.word	0xe3a0b000
   10488:	e3a0e000 	.word	0xe3a0e000
   1048c:	e49d1004 	.word	0xe49d1004
   10490:	e1a0200d 	.word	0xe1a0200d
   10494:	e52d2004 	.word	0xe52d2004
   10498:	e52d0004 	.word	0xe52d0004
   1049c:	e59fc010 	.word	0xe59fc010
   104a0:	e52dc004 	.word	0xe52dc004
   104a4:	e59f000c 	.word	0xe59f000c
   104a8:	e59f300c 	.word	0xe59f300c
   104ac:	eaffffe8 	.word	0xeaffffe8
   104b0:	ebffffe1 	.word	0xebffffe1
   104b4:	000109dc 	.word	0x000109dc
   104b8:	00010980 	.word	0x00010980
   104bc:	000103e8 	.word	0x000103e8

000104c0 <deregister_tm_clones>:
   104c0:	e59f301c 	ldr	r3, [pc, #28]	; 104e4 <deregister_tm_clones+0x24>
   104c4:	e59f001c 	ldr	r0, [pc, #28]	; 104e8 <deregister_tm_clones+0x28>
   104c8:	e0603003 	rsb	r3, r0, r3
   104cc:	e3530006 	cmp	r3, #6
   104d0:	912fff1e 	bxls	lr
   104d4:	e59f3010 	ldr	r3, [pc, #16]	; 104ec <deregister_tm_clones+0x2c>
   104d8:	e3530000 	cmp	r3, #0
   104dc:	012fff1e 	bxeq	lr
   104e0:	e12fff13 	bx	r3
   104e4:	00020b5f 	.word	0x00020b5f
   104e8:	00020b5c 	.word	0x00020b5c
   104ec:	00000000 	.word	0x00000000

000104f0 <register_tm_clones>:
   104f0:	e59f1024 	ldr	r1, [pc, #36]	; 1051c <register_tm_clones+0x2c>
   104f4:	e59f0024 	ldr	r0, [pc, #36]	; 10520 <register_tm_clones+0x30>
   104f8:	e0601001 	rsb	r1, r0, r1
   104fc:	e1a01141 	asr	r1, r1, #2
   10500:	e0811fa1 	add	r1, r1, r1, lsr #31
   10504:	e1b010c1 	asrs	r1, r1, #1
   10508:	012fff1e 	bxeq	lr
   1050c:	e59f3010 	ldr	r3, [pc, #16]	; 10524 <register_tm_clones+0x34>
   10510:	e3530000 	cmp	r3, #0
   10514:	012fff1e 	bxeq	lr
   10518:	e12fff13 	bx	r3
   1051c:	00020b5c 	.word	0x00020b5c
   10520:	00020b5c 	.word	0x00020b5c
   10524:	00000000 	.word	0x00000000

00010528 <__do_global_dtors_aux>:
   10528:	e92d4010 	push	{r4, lr}
   1052c:	e59f402c 	ldr	r4, [pc, #44]	; 10560 <__do_global_dtors_aux+0x38>
   10530:	e5d43000 	ldrb	r3, [r4]
   10534:	e3530000 	cmp	r3, #0
   10538:	18bd8010 	popne	{r4, pc}
   1053c:	ebffffdf 	bl	104c0 <deregister_tm_clones>
   10540:	e59f301c 	ldr	r3, [pc, #28]	; 10564 <__do_global_dtors_aux+0x3c>
   10544:	e3530000 	cmp	r3, #0
   10548:	0a000001 	beq	10554 <__do_global_dtors_aux+0x2c>
   1054c:	e59f0014 	ldr	r0, [pc, #20]	; 10568 <__do_global_dtors_aux+0x40>
   10550:	ebffffbc 	bl	10448 <__deregister_frame_info@plt>
   10554:	e3a03001 	mov	r3, #1
   10558:	e5c43000 	strb	r3, [r4]
   1055c:	e8bd8010 	pop	{r4, pc}
   10560:	00020b5c 	.word	0x00020b5c
   10564:	00000000 	.word	0x00000000
   10568:	00010a58 	.word	0x00010a58

0001056c <frame_dummy>:
   1056c:	e59f3040 	ldr	r3, [pc, #64]	; 105b4 <frame_dummy+0x48>
   10570:	e92d4010 	push	{r4, lr}
   10574:	e3530000 	cmp	r3, #0
   10578:	0a000002 	beq	10588 <frame_dummy+0x1c>
   1057c:	e59f1034 	ldr	r1, [pc, #52]	; 105b8 <frame_dummy+0x4c>
   10580:	e59f0034 	ldr	r0, [pc, #52]	; 105bc <frame_dummy+0x50>
   10584:	ebffffb8 	bl	1046c <__register_frame_info@plt>
   10588:	e59f0030 	ldr	r0, [pc, #48]	; 105c0 <frame_dummy+0x54>
   1058c:	e5903000 	ldr	r3, [r0]
   10590:	e3530000 	cmp	r3, #0
   10594:	1a000001 	bne	105a0 <frame_dummy+0x34>
   10598:	e8bd4010 	pop	{r4, lr}
   1059c:	eaffffd3 	b	104f0 <register_tm_clones>
   105a0:	e59f301c 	ldr	r3, [pc, #28]	; 105c4 <frame_dummy+0x58>
   105a4:	e3530000 	cmp	r3, #0
   105a8:	0afffffa 	beq	10598 <frame_dummy+0x2c>
   105ac:	e12fff33 	blx	r3
   105b0:	eafffff8 	b	10598 <frame_dummy+0x2c>
   105b4:	00000000 	.word	0x00000000
   105b8:	00020b60 	.word	0x00020b60
   105bc:	00010a58 	.word	0x00010a58
   105c0:	00020a64 	.word	0x00020a64
   105c4:	00000000 	.word	0x00000000

000105c8 <creat>:
  struct list * prev;
  struct list * next;
};

struct list * creat()
{
   105c8:	e92d4800 	push	{fp, lr}
   105cc:	e28db004 	add	fp, sp, #4
   105d0:	e24dd018 	sub	sp, sp, #24
  struct list * head, * src, * des;
  int value, cycle = 1;
   105d4:	e3a03001 	mov	r3, #1
   105d8:	e50b300c 	str	r3, [fp, #-12]

  head = (struct list *) malloc (sizeof(struct list));
   105dc:	e3a0000c 	mov	r0, #12
   105e0:	ebffff92 	bl	10430 <malloc@plt>
   105e4:	e1a03000 	mov	r3, r0
   105e8:	e50b3010 	str	r3, [fp, #-16]

  src = head;
   105ec:	e51b3010 	ldr	r3, [fp, #-16]
   105f0:	e50b3008 	str	r3, [fp, #-8]
  while (cycle) {
   105f4:	ea00001f 	b	10678 <creat+0xb0>
    printf("input the data:\n");
   105f8:	e59f00cc 	ldr	r0, [pc, #204]	; 106cc <creat+0x104>
   105fc:	ebffff88 	bl	10424 <puts@plt>
    scanf("%d", & value);
   10600:	e24b3018 	sub	r3, fp, #24
   10604:	e1a01003 	mov	r1, r3
   10608:	e59f00c0 	ldr	r0, [pc, #192]	; 106d0 <creat+0x108>
   1060c:	ebffff93 	bl	10460 <scanf@plt>
    if (value != 0) {
   10610:	e51b3018 	ldr	r3, [fp, #-24]	; 0xffffffe8
   10614:	e3530000 	cmp	r3, #0
   10618:	0a000014 	beq	10670 <creat+0xa8>
      des = (struct list *) malloc (sizeof(struct list));
   1061c:	e3a0000c 	mov	r0, #12
   10620:	ebffff82 	bl	10430 <malloc@plt>
   10624:	e1a03000 	mov	r3, r0
   10628:	e50b3014 	str	r3, [fp, #-20]	; 0xffffffec
      des->num = value;
   1062c:	e51b2018 	ldr	r2, [fp, #-24]	; 0xffffffe8
   10630:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10634:	e5832000 	str	r2, [r3]
      printf(" %d ", des->num);
   10638:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   1063c:	e5933000 	ldr	r3, [r3]
   10640:	e1a01003 	mov	r1, r3
   10644:	e59f0088 	ldr	r0, [pc, #136]	; 106d4 <creat+0x10c>
   10648:	ebffff72 	bl	10418 <printf@plt>
      src->next = des;
   1064c:	e51b3008 	ldr	r3, [fp, #-8]
   10650:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   10654:	e5832008 	str	r2, [r3, #8]
      des->prev = src;
   10658:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   1065c:	e51b2008 	ldr	r2, [fp, #-8]
   10660:	e5832004 	str	r2, [r3, #4]
      src = des;
   10664:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10668:	e50b3008 	str	r3, [fp, #-8]
   1066c:	ea000001 	b	10678 <creat+0xb0>
    }
    else
      cycle = 0;
   10670:	e3a03000 	mov	r3, #0
   10674:	e50b300c 	str	r3, [fp, #-12]
  int value, cycle = 1;

  head = (struct list *) malloc (sizeof(struct list));

  src = head;
  while (cycle) {
   10678:	e51b300c 	ldr	r3, [fp, #-12]
   1067c:	e3530000 	cmp	r3, #0
   10680:	1affffdc 	bne	105f8 <creat+0x30>
      src = des;
    }
    else
      cycle = 0;
  }
  head = head->next;
   10684:	e51b3010 	ldr	r3, [fp, #-16]
   10688:	e5933008 	ldr	r3, [r3, #8]
   1068c:	e50b3010 	str	r3, [fp, #-16]
  head->prev = NULL;
   10690:	e51b3010 	ldr	r3, [fp, #-16]
   10694:	e3a02000 	mov	r2, #0
   10698:	e5832004 	str	r2, [r3, #4]
  src->next = NULL;
   1069c:	e51b3008 	ldr	r3, [fp, #-8]
   106a0:	e3a02000 	mov	r2, #0
   106a4:	e5832008 	str	r2, [r3, #8]

  printf("\n head : %d ", head->num);
   106a8:	e51b3010 	ldr	r3, [fp, #-16]
   106ac:	e5933000 	ldr	r3, [r3]
   106b0:	e1a01003 	mov	r1, r3
   106b4:	e59f001c 	ldr	r0, [pc, #28]	; 106d8 <creat+0x110>
   106b8:	ebffff56 	bl	10418 <printf@plt>
  return head;
   106bc:	e51b3010 	ldr	r3, [fp, #-16]
}
   106c0:	e1a00003 	mov	r0, r3
   106c4:	e24bd004 	sub	sp, fp, #4
   106c8:	e8bd8800 	pop	{fp, pc}
   106cc:	000109ec 	.word	0x000109ec
   106d0:	000109fc 	.word	0x000109fc
   106d4:	00010a00 	.word	0x00010a00
   106d8:	00010a08 	.word	0x00010a08

000106dc <display>:

void display(struct list * head)
{
   106dc:	e92d4800 	push	{fp, lr}
   106e0:	e28db004 	add	fp, sp, #4
   106e4:	e24dd010 	sub	sp, sp, #16
   106e8:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;

  src = head;
   106ec:	e51b3010 	ldr	r3, [fp, #-16]
   106f0:	e50b3008 	str	r3, [fp, #-8]
  if (head != NULL) {
   106f4:	e51b3010 	ldr	r3, [fp, #-16]
   106f8:	e3530000 	cmp	r3, #0
   106fc:	0a00000b 	beq	10730 <display+0x54>
    while (src != NULL) {
   10700:	ea000007 	b	10724 <display+0x48>
      printf(" %d ", src->num);
   10704:	e51b3008 	ldr	r3, [fp, #-8]
   10708:	e5933000 	ldr	r3, [r3]
   1070c:	e1a01003 	mov	r1, r3
   10710:	e59f0028 	ldr	r0, [pc, #40]	; 10740 <display+0x64>
   10714:	ebffff3f 	bl	10418 <printf@plt>
      src = src->next;
   10718:	e51b3008 	ldr	r3, [fp, #-8]
   1071c:	e5933008 	ldr	r3, [r3, #8]
   10720:	e50b3008 	str	r3, [fp, #-8]
{
  struct list * src;

  src = head;
  if (head != NULL) {
    while (src != NULL) {
   10724:	e51b3008 	ldr	r3, [fp, #-8]
   10728:	e3530000 	cmp	r3, #0
   1072c:	1afffff4 	bne	10704 <display+0x28>
      printf(" %d ", src->num);
      src = src->next;
    }
  }
  printf("\n");
   10730:	e3a0000a 	mov	r0, #10
   10734:	ebffff34 	bl	1040c <putchar@plt>
}
   10738:	e24bd004 	sub	sp, fp, #4
   1073c:	e8bd8800 	pop	{fp, pc}
   10740:	00010a00 	.word	0x00010a00

00010744 <delete>:

struct list * delete(struct list * head, int value)
{
   10744:	e92d4800 	push	{fp, lr}
   10748:	e28db004 	add	fp, sp, #4
   1074c:	e24dd010 	sub	sp, sp, #16
   10750:	e50b0010 	str	r0, [fp, #-16]
   10754:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src;

  src = head;
   10758:	e51b3010 	ldr	r3, [fp, #-16]
   1075c:	e50b3008 	str	r3, [fp, #-8]
  while (value != src->num && src->next != NULL)
   10760:	ea000002 	b	10770 <delete+0x2c>
    src = src->next;
   10764:	e51b3008 	ldr	r3, [fp, #-8]
   10768:	e5933008 	ldr	r3, [r3, #8]
   1076c:	e50b3008 	str	r3, [fp, #-8]
struct list * delete(struct list * head, int value)
{
  struct list * src;

  src = head;
  while (value != src->num && src->next != NULL)
   10770:	e51b3008 	ldr	r3, [fp, #-8]
   10774:	e5932000 	ldr	r2, [r3]
   10778:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   1077c:	e1520003 	cmp	r2, r3
   10780:	0a000003 	beq	10794 <delete+0x50>
   10784:	e51b3008 	ldr	r3, [fp, #-8]
   10788:	e5933008 	ldr	r3, [r3, #8]
   1078c:	e3530000 	cmp	r3, #0
   10790:	1afffff3 	bne	10764 <delete+0x20>
    src = src->next;

  if (value == src->num) {
   10794:	e51b3008 	ldr	r3, [fp, #-8]
   10798:	e5932000 	ldr	r2, [r3]
   1079c:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   107a0:	e1520003 	cmp	r2, r3
   107a4:	1a000022 	bne	10834 <delete+0xf0>
    if (src == head) {
   107a8:	e51b2008 	ldr	r2, [fp, #-8]
   107ac:	e51b3010 	ldr	r3, [fp, #-16]
   107b0:	e1520003 	cmp	r2, r3
   107b4:	1a000008 	bne	107dc <delete+0x98>
      head = head->next;
   107b8:	e51b3010 	ldr	r3, [fp, #-16]
   107bc:	e5933008 	ldr	r3, [r3, #8]
   107c0:	e50b3010 	str	r3, [fp, #-16]
      head->prev = NULL;
   107c4:	e51b3010 	ldr	r3, [fp, #-16]
   107c8:	e3a02000 	mov	r2, #0
   107cc:	e5832004 	str	r2, [r3, #4]
      free(src);
   107d0:	e51b0008 	ldr	r0, [fp, #-8]
   107d4:	ebffff27 	bl	10478 <free@plt>
   107d8:	ea000018 	b	10840 <delete+0xfc>
    }
    else if (src->next == NULL) {
   107dc:	e51b3008 	ldr	r3, [fp, #-8]
   107e0:	e5933008 	ldr	r3, [r3, #8]
   107e4:	e3530000 	cmp	r3, #0
   107e8:	1a000006 	bne	10808 <delete+0xc4>
      src->prev->next = NULL;
   107ec:	e51b3008 	ldr	r3, [fp, #-8]
   107f0:	e5933004 	ldr	r3, [r3, #4]
   107f4:	e3a02000 	mov	r2, #0
   107f8:	e5832008 	str	r2, [r3, #8]
      free(src);
   107fc:	e51b0008 	ldr	r0, [fp, #-8]
   10800:	ebffff1c 	bl	10478 <free@plt>
   10804:	ea00000d 	b	10840 <delete+0xfc>
    }
    else {
      src->next->prev = src->prev;
   10808:	e51b3008 	ldr	r3, [fp, #-8]
   1080c:	e5933008 	ldr	r3, [r3, #8]
   10810:	e51b2008 	ldr	r2, [fp, #-8]
   10814:	e5922004 	ldr	r2, [r2, #4]
   10818:	e5832004 	str	r2, [r3, #4]
      src->prev->next = src->next;
   1081c:	e51b3008 	ldr	r3, [fp, #-8]
   10820:	e5933004 	ldr	r3, [r3, #4]
   10824:	e51b2008 	ldr	r2, [fp, #-8]
   10828:	e5922008 	ldr	r2, [r2, #8]
   1082c:	e5832008 	str	r2, [r3, #8]
   10830:	ea000002 	b	10840 <delete+0xfc>
    }
  }
  else
    printf(" %d could not been found!\n", value);
   10834:	e51b1014 	ldr	r1, [fp, #-20]	; 0xffffffec
   10838:	e59f0010 	ldr	r0, [pc, #16]	; 10850 <delete+0x10c>
   1083c:	ebfffef5 	bl	10418 <printf@plt>

  return head;
   10840:	e51b3010 	ldr	r3, [fp, #-16]
}
   10844:	e1a00003 	mov	r0, r3
   10848:	e24bd004 	sub	sp, fp, #4
   1084c:	e8bd8800 	pop	{fp, pc}
   10850:	00010a18 	.word	0x00010a18

00010854 <insert>:

struct list * insert(struct list * head, int value)
{
   10854:	e92d4800 	push	{fp, lr}
   10858:	e28db004 	add	fp, sp, #4
   1085c:	e24dd010 	sub	sp, sp, #16
   10860:	e50b0010 	str	r0, [fp, #-16]
   10864:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src, * des;
  
  src = head;
   10868:	e51b3010 	ldr	r3, [fp, #-16]
   1086c:	e50b3008 	str	r3, [fp, #-8]
  des = (struct list *) malloc (sizeof(struct list));
   10870:	e3a0000c 	mov	r0, #12
   10874:	ebfffeed 	bl	10430 <malloc@plt>
   10878:	e1a03000 	mov	r3, r0
   1087c:	e50b300c 	str	r3, [fp, #-12]
  des->num = value;
   10880:	e51b300c 	ldr	r3, [fp, #-12]
   10884:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   10888:	e5832000 	str	r2, [r3]

  while (des->num > src->num && src->next != NULL) {
   1088c:	ea000002 	b	1089c <insert+0x48>
    src = src->next;
   10890:	e51b3008 	ldr	r3, [fp, #-8]
   10894:	e5933008 	ldr	r3, [r3, #8]
   10898:	e50b3008 	str	r3, [fp, #-8]
  
  src = head;
  des = (struct list *) malloc (sizeof(struct list));
  des->num = value;

  while (des->num > src->num && src->next != NULL) {
   1089c:	e51b300c 	ldr	r3, [fp, #-12]
   108a0:	e5932000 	ldr	r2, [r3]
   108a4:	e51b3008 	ldr	r3, [fp, #-8]
   108a8:	e5933000 	ldr	r3, [r3]
   108ac:	e1520003 	cmp	r2, r3
   108b0:	da000003 	ble	108c4 <insert+0x70>
   108b4:	e51b3008 	ldr	r3, [fp, #-8]
   108b8:	e5933008 	ldr	r3, [r3, #8]
   108bc:	e3530000 	cmp	r3, #0
   108c0:	1afffff2 	bne	10890 <insert+0x3c>
    src = src->next;
  }
  if (des->num <= src->num) {
   108c4:	e51b300c 	ldr	r3, [fp, #-12]
   108c8:	e5932000 	ldr	r2, [r3]
   108cc:	e51b3008 	ldr	r3, [fp, #-8]
   108d0:	e5933000 	ldr	r3, [r3]
   108d4:	e1520003 	cmp	r2, r3
   108d8:	ca00001b 	bgt	1094c <insert+0xf8>
    if (head == src) {
   108dc:	e51b2010 	ldr	r2, [fp, #-16]
   108e0:	e51b3008 	ldr	r3, [fp, #-8]
   108e4:	e1520003 	cmp	r2, r3
   108e8:	1a000008 	bne	10910 <insert+0xbc>
      des->next = src;
   108ec:	e51b300c 	ldr	r3, [fp, #-12]
   108f0:	e51b2008 	ldr	r2, [fp, #-8]
   108f4:	e5832008 	str	r2, [r3, #8]
      src->prev = des;
   108f8:	e51b3008 	ldr	r3, [fp, #-8]
   108fc:	e51b200c 	ldr	r2, [fp, #-12]
   10900:	e5832004 	str	r2, [r3, #4]
      head = des;
   10904:	e51b300c 	ldr	r3, [fp, #-12]
   10908:	e50b3010 	str	r3, [fp, #-16]
   1090c:	ea000017 	b	10970 <insert+0x11c>
    }
    else {
      src->prev->next = des;
   10910:	e51b3008 	ldr	r3, [fp, #-8]
   10914:	e5933004 	ldr	r3, [r3, #4]
   10918:	e51b200c 	ldr	r2, [fp, #-12]
   1091c:	e5832008 	str	r2, [r3, #8]
      des->next = src;
   10920:	e51b300c 	ldr	r3, [fp, #-12]
   10924:	e51b2008 	ldr	r2, [fp, #-8]
   10928:	e5832008 	str	r2, [r3, #8]
      des->prev = src->prev;
   1092c:	e51b3008 	ldr	r3, [fp, #-8]
   10930:	e5932004 	ldr	r2, [r3, #4]
   10934:	e51b300c 	ldr	r3, [fp, #-12]
   10938:	e5832004 	str	r2, [r3, #4]
      src->prev = des;
   1093c:	e51b3008 	ldr	r3, [fp, #-8]
   10940:	e51b200c 	ldr	r2, [fp, #-12]
   10944:	e5832004 	str	r2, [r3, #4]
   10948:	ea000008 	b	10970 <insert+0x11c>
    }
  }
  else {
    src->next = des;
   1094c:	e51b3008 	ldr	r3, [fp, #-8]
   10950:	e51b200c 	ldr	r2, [fp, #-12]
   10954:	e5832008 	str	r2, [r3, #8]
    des->prev = src;
   10958:	e51b300c 	ldr	r3, [fp, #-12]
   1095c:	e51b2008 	ldr	r2, [fp, #-8]
   10960:	e5832004 	str	r2, [r3, #4]
    des->next = NULL;
   10964:	e51b300c 	ldr	r3, [fp, #-12]
   10968:	e3a02000 	mov	r2, #0
   1096c:	e5832008 	str	r2, [r3, #8]
  }

  return head;
   10970:	e51b3010 	ldr	r3, [fp, #-16]
}
   10974:	e1a00003 	mov	r0, r3
   10978:	e24bd004 	sub	sp, fp, #4
   1097c:	e8bd8800 	pop	{fp, pc}

00010980 <main>:

int main()
{
   10980:	e92d4800 	push	{fp, lr}
   10984:	e28db004 	add	fp, sp, #4
   10988:	e24dd008 	sub	sp, sp, #8
  struct list * head;
  int value;

  head = creat();
   1098c:	ebffff0d 	bl	105c8 <creat>
   10990:	e50b0008 	str	r0, [fp, #-8]
  printf("input the number to be inserted:\n");
   10994:	e59f0038 	ldr	r0, [pc, #56]	; 109d4 <main+0x54>
   10998:	ebfffea1 	bl	10424 <puts@plt>
  scanf("%d", & value);
   1099c:	e24b300c 	sub	r3, fp, #12
   109a0:	e1a01003 	mov	r1, r3
   109a4:	e59f002c 	ldr	r0, [pc, #44]	; 109d8 <main+0x58>
   109a8:	ebfffeac 	bl	10460 <scanf@plt>
  
  head = insert(head, value);
   109ac:	e51b300c 	ldr	r3, [fp, #-12]
   109b0:	e1a01003 	mov	r1, r3
   109b4:	e51b0008 	ldr	r0, [fp, #-8]
   109b8:	ebffffa5 	bl	10854 <insert>
   109bc:	e50b0008 	str	r0, [fp, #-8]
  display(head);
   109c0:	e51b0008 	ldr	r0, [fp, #-8]
   109c4:	ebffff44 	bl	106dc <display>
}
   109c8:	e1a00003 	mov	r0, r3
   109cc:	e24bd004 	sub	sp, fp, #4
   109d0:	e8bd8800 	pop	{fp, pc}
   109d4:	00010a34 	.word	0x00010a34
   109d8:	000109fc 	.word	0x000109fc

Disassembly of section .fini:

000109dc <_fini>:
   109dc:	e1a0c00d 	mov	ip, sp
   109e0:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   109e4:	e24cb004 	sub	fp, ip, #4
   109e8:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
